home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / lib / c / etc / RCS / pfs.c,v < prev    next >
Text File  |  1992-04-27  |  26KB  |  951 lines
  1. head     1.5;
  2. branch   ;
  3. access   ;
  4. symbols  sprited:1.5.1;
  5. locks    ; strict;
  6. comment  @ * @;
  7.  
  8.  
  9. 1.5
  10. date     89.09.12.14.42.42;  author brent;  state Exp;
  11. branches 1.5.1.1;
  12. next     1.4;
  13.  
  14. 1.4
  15. date     89.06.15.11.50.20;  author brent;  state Exp;
  16. branches ;
  17. next     1.3;
  18.  
  19. 1.3
  20. date     89.06.02.15.01.22;  author brent;  state Exp;
  21. branches ;
  22. next     1.2;
  23.  
  24. 1.2
  25. date     89.04.06.08.23.20;  author brent;  state Exp;
  26. branches ;
  27. next     1.1;
  28.  
  29. 1.1
  30. date     89.02.02.15.00.39;  author brent;  state Exp;
  31. branches ;
  32. next     ;
  33.  
  34. 1.5.1.1
  35. date     92.04.26.21.55.02;  author kupfer;  state Exp;
  36. branches ;
  37. next     ;
  38.  
  39.  
  40. desc
  41. @Pseudo-file-system server package
  42. @
  43.  
  44.  
  45. 1.5
  46. log
  47. @Updated to new Fs_ typedefs
  48. @
  49. text
  50. @/* 
  51.  * pfs.c --
  52.  *
  53.  *    The routines in this module set up a call-back interface for
  54.  *    a pseudo-file-system server.  Call-back procedures are called
  55.  *    when client processes do naming operation on the pseudo-file-system.
  56.  *    As a side-effect of the PFS_OPEN operation a pseudo-device connection
  57.  *    can be created for the I/O operations on the object in the
  58.  *    pseudo-file-system.  Pfs_OpenConnection is used to do this, and it
  59.  *    sets of a set of service call-backs for the pseudo-device connenction.
  60.  *    Thus a pseudo-file-system server has a set of naming service
  61.  *    call-backs (typedef Pfs_CallBacks) that are tied to a single
  62.  *    "naming" stream, and another set of I/O service call-backs
  63.  *    (typedef Pdev_CallBacks) for each open file in the pseudo-file-system.
  64.  *
  65.  * Copyright 1989 Regents of the University of California
  66.  * Permission to use, copy, modify, and distribute this
  67.  * software and its documentation for any purpose and without
  68.  * fee is hereby granted, provided that the above copyright
  69.  * notice appear in all copies.  The University of California
  70.  * makes no representations about the suitability of this
  71.  * software for any purpose.  It is provided "as is" without
  72.  * express or implied warranty.
  73.  */
  74.  
  75. #ifndef lint
  76. static char rcsid[] = "$Header: /sprite/src/lib/c/etc/RCS/pfs.c,v 1.4 89/06/15 11:50:20 brent Exp $ SPRITE (Berkeley)";
  77. #endif not lint
  78.  
  79. #include <stdio.h>
  80. #include <sprite.h>
  81. #include <ctype.h>
  82. #include <errno.h>
  83. #include <pfs.h>
  84. #include <list.h>
  85. #include <status.h>
  86. #include <stdlib.h>
  87. #include <string.h>
  88. #include <sys/file.h>
  89.  
  90. /*
  91.  * The string below holds an error message if Pfs_Open fails.
  92.  */
  93.  
  94. char pfs_ErrorMsg[150];
  95.  
  96. typedef struct Server {
  97.     unsigned int magic;        /* PFS_MAGIC */
  98.     int streamID;        /* StreamID of naming request-response */
  99.     List_Links connectList;    /* List of all service streams for this
  100.                  * pseudo-filesystem. */
  101.     Pfs_CallBacks *nameService;    /* Naming handlers for pfs operations */
  102.     char *prefix;        /* Pseudo-filesystem prefix */
  103.     Address requestBuf;        /* Naming connection request buffer */
  104.     ClientData clientData;    /* Passed to naming service procedures */
  105. } Server;
  106.  
  107. /*
  108.  * Boolean that can be toggled by applications to get tracing.
  109.  */
  110. int pfs_Trace;
  111.  
  112. static int    PfsNullProc();
  113.  
  114. static Pfs_CallBacks pfsDefaultCallBacks = {
  115.     PfsNullProc,        /* PFS_OPEN */
  116.     PfsNullProc,        /* PFS_GET_ATTR */
  117.     PfsNullProc,        /* PFS_SET_ATTR */
  118.     PfsNullProc,        /* PFS_MAKE_DEVICE */
  119.     PfsNullProc,        /* PFS_MAKE_DIR */
  120.     PfsNullProc,        /* PFS_REMOVE */
  121.     PfsNullProc,        /* PFS_REMOVE_DIR */
  122.     PfsNullProc,        /* PFS_HARD_LINK */
  123.     PfsNullProc,        /* PFS_SYM_LINK */
  124.     PfsNullProc,        /* PFS_DOMAIN_INFO */
  125. };
  126.  
  127. /*
  128.  * PFS_REQUEST_BUF_SIZE     Size of the request buffer for naming stream.
  129.  */
  130.  
  131. #define PFS_REQUEST_BUF_SIZE    (sizeof(Pfs_Request) + sizeof(Fs_2PathData))
  132.  
  133. /*
  134.  * Forward references to procedures in this file:
  135.  */
  136.  
  137. extern void    PfsNamingRequest();
  138.  
  139. /*
  140.  *----------------------------------------------------------------------
  141.  *
  142.  * Pfs_Open --
  143.  *
  144.  *    Establish a pseudo-filesystem server with a given set of handler
  145.  *    procedures both for the naming operations to the pseudo-filesystem,
  146.  *    and for the I/O operations on pseudo-device connections established
  147.  *    inside the pseudo-filesystem.
  148.  * 
  149.  * Results:
  150.  *    An pointer to a token that contains a clientData field for use
  151.  *    by the caller of Pfs_Open, and the streamID of the naming
  152.  *    request-response stream.  This pointer gets be passed
  153.  *    to Pfs_Close and Pfs_SetHandler.
  154.  *
  155.  * Side effects:
  156.  *    Opens the pseudo-filesystem.  Sets up a call-back.
  157.  *
  158.  *----------------------------------------------------------------------
  159.  */
  160. Pfs_Token
  161. Pfs_Open(prefix, rootIDPtr, service, clientData)
  162.     char *prefix;        /* Prefix of the pseudo-filesystem */
  163.     Fs_FileID *rootIDPtr;    /* Server-defined ID of the root */
  164.     Pfs_CallBacks *service;    /* Set of callback procedures.  Can be NULL,
  165.                  * or individual elements can be NULL, to
  166.                  * get default callbacks. */
  167.     ClientData clientData;    /* Passed to naming callbacks */
  168. {
  169.     int namingFD;
  170.     register Server *pfsPtr;
  171.     register int op;
  172.     Pdev_SetBufArgs setBuf;
  173.     int status;
  174.  
  175.     namingFD = open(prefix, O_PFS_MASTER|O_RDONLY, 0);
  176.     if (namingFD < 0) {
  177.     sprintf(pfs_ErrorMsg, "Pfs_Open: \"%s\" service failed, errno %d",
  178.         prefix, errno);
  179.     return((Pfs_Token)NULL);
  180.     }
  181.  
  182.     pfsPtr = (Server *)malloc(sizeof(Server));
  183.     pfsPtr->magic = PFS_MAGIC;
  184.     pfsPtr->streamID = namingFD;
  185.     pfsPtr->clientData = clientData;
  186.  
  187.     List_Init(&pfsPtr->connectList);
  188.  
  189.     pfsPtr->nameService = (Pfs_CallBacks *)malloc(sizeof(Pfs_CallBacks));
  190.     if (service == (Pfs_CallBacks *)NULL) {
  191.     bcopy((Address) &pfsDefaultCallBacks, (Address) pfsPtr->nameService,
  192.             sizeof(Pfs_CallBacks));
  193.     } else {
  194.     bcopy((Address) service, (Address) pfsPtr->nameService,
  195.             sizeof(Pfs_CallBacks));
  196.     }
  197.     if (pfsPtr->nameService->open == (int (*)())NULL) {
  198.     pfsPtr->nameService->open = pfsDefaultCallBacks.open;
  199.     }
  200.     if (pfsPtr->nameService->getAttr == (int (*)())NULL) {
  201.     pfsPtr->nameService->getAttr = pfsDefaultCallBacks.getAttr;
  202.     }
  203.     if (pfsPtr->nameService->setAttr == (int (*)())NULL) {
  204.     pfsPtr->nameService->setAttr = pfsDefaultCallBacks.setAttr;
  205.     }
  206.     if (pfsPtr->nameService->makeDevice == (int (*)())NULL) {
  207.     pfsPtr->nameService->makeDevice = pfsDefaultCallBacks.makeDevice;
  208.     }
  209.     if (pfsPtr->nameService->makeDir == (int (*)())NULL) {
  210.     pfsPtr->nameService->makeDir = pfsDefaultCallBacks.makeDir;
  211.     }
  212.     if (pfsPtr->nameService->remove == (int (*)())NULL) {
  213.     pfsPtr->nameService->remove = pfsDefaultCallBacks.remove;
  214.     }
  215.     if (pfsPtr->nameService->removeDir == (int (*)())NULL) {
  216.     pfsPtr->nameService->removeDir = pfsDefaultCallBacks.removeDir;
  217.     }
  218.     if (pfsPtr->nameService->rename == (int (*)())NULL) {
  219.     pfsPtr->nameService->rename = pfsDefaultCallBacks.rename;
  220.     }
  221.     if (pfsPtr->nameService->hardLink == (int (*)())NULL) {
  222.     pfsPtr->nameService->hardLink = pfsDefaultCallBacks.hardLink;
  223.     }
  224.     if (pfsPtr->nameService->symLink == (int (*)())NULL) {
  225.     pfsPtr->nameService->symLink = pfsDefaultCallBacks.symLink;
  226.     }
  227.     if (pfsPtr->nameService->domainInfo == (int (*)())NULL) {
  228.     pfsPtr->nameService->domainInfo = pfsDefaultCallBacks.domainInfo;
  229.     }
  230.  
  231.     pfsPtr->prefix = prefix;
  232.     pfsPtr->requestBuf = (Address)malloc(PFS_REQUEST_BUF_SIZE);
  233.     setBuf.requestBufAddr = pfsPtr->requestBuf;
  234.     setBuf.requestBufSize = PFS_REQUEST_BUF_SIZE;
  235.     setBuf.readBufAddr = NULL;
  236.     setBuf.readBufSize = 0;
  237.     status = Fs_IOControl(namingFD, IOC_PDEV_SET_BUF, sizeof(Pdev_SetBufArgs),
  238.         (Address)&setBuf, 0, (Address) NULL);
  239.     if (status != SUCCESS) {
  240.     sprintf(pfs_ErrorMsg, "IOC_PDEV_SET_BUF failed <%x>\n", status);
  241.     close(namingFD);
  242.     return((Pfs_Token)NULL);
  243.     }
  244.     (void)Fs_IOControl(namingFD, IOC_PFS_SET_ID, sizeof(Fs_FileID),
  245.         (Address)rootIDPtr, 0, (Address) NULL);
  246.  
  247.     Fs_EventHandlerCreate(namingFD, FS_READABLE, PfsNamingRequest,
  248.                 (ClientData)pfsPtr);
  249.  
  250.     return((Pfs_Token)pfsPtr);
  251. }
  252.  
  253. /*
  254.  *----------------------------------------------------------------------
  255.  *
  256.  * Pfs_SetHandler --
  257.  *
  258.  *    Set a handler for a particular PFS request.  If the handler is
  259.  *    NULL then a default procedure replaces the existing handler.
  260.  * 
  261.  * Results:
  262.  *    None.
  263.  *
  264.  * Side effects:
  265.  *    Updates the top-level callback list, the one used for naming requests.
  266.  *
  267.  *----------------------------------------------------------------------
  268.  */
  269. int (*
  270. Pfs_SetHandler(pfsToken, operation, handler))()
  271.     Pfs_Token pfsToken;        /* Return value from Pfs_Open */
  272.     int operation;        /* Which operation to set the handler for */
  273.     int (*handler)();        /* The callback procedure */
  274. {
  275.     register Server *pfsPtr = (Server *)pfsToken;
  276.     register Pfs_CallBacks *service = pfsPtr->nameService;
  277.     int (*oldHandler)();
  278.  
  279.     if (pfsPtr->magic != PFS_MAGIC) {
  280.     fprintf(stderr, "Bad token passed to Pfs_SetHandler\n");
  281.     return NULL;
  282.     }
  283.     switch (operation) {
  284.     case PFS_OPEN:
  285.         oldHandler = service->open;
  286.         if (handler == (int (*)())NULL) {
  287.         service->open = PfsNullProc;
  288.         } else {
  289.         service->open = handler;
  290.         }
  291.         break;
  292.     case PFS_GET_ATTR:
  293.         oldHandler = service->getAttr;
  294.         if (handler == (int (*)())NULL) {
  295.         service->getAttr = PfsNullProc;
  296.         } else {
  297.         service->getAttr = handler;
  298.         }
  299.         break;
  300.     case PFS_SET_ATTR:
  301.         oldHandler = service->setAttr;
  302.         if (handler == (int (*)())NULL) {
  303.         service->setAttr = PfsNullProc;
  304.         } else {
  305.         service->setAttr = handler;
  306.         }
  307.         break;
  308.     case PFS_MAKE_DEVICE:
  309.         oldHandler = service->makeDevice;
  310.         if (handler == (int (*)())NULL) {
  311.         service->makeDevice = PfsNullProc;
  312.         } else {
  313.         service->makeDevice = handler;
  314.         }
  315.         break;
  316.     case PFS_MAKE_DIR:
  317.         oldHandler = service->makeDir;
  318.         if (handler == (int (*)())NULL) {
  319.         service->makeDir = PfsNullProc;
  320.         } else {
  321.         service->makeDir = handler;
  322.         }
  323.         break;
  324.     case PFS_REMOVE:
  325.         oldHandler = service->remove;
  326.         if (handler == (int (*)())NULL) {
  327.         service->remove = PfsNullProc;
  328.         } else {
  329.         service->remove = handler;
  330.         }
  331.         break;
  332.     case PFS_REMOVE_DIR:
  333.         oldHandler = service->removeDir;
  334.         if (handler == (int (*)())NULL) {
  335.         service->removeDir = PfsNullProc;
  336.         } else {
  337.         service->removeDir = handler;
  338.         }
  339.         break;
  340.     case PFS_RENAME:
  341.         oldHandler = service->rename;
  342.         if (handler == (int (*)())NULL) {
  343.         service->rename = PfsNullProc;
  344.         } else {
  345.         service->rename = handler;
  346.         }
  347.         break;
  348.     case PFS_HARD_LINK:
  349.         oldHandler = service->hardLink;
  350.         if (handler == (int (*)())NULL) {
  351.         service->hardLink = PfsNullProc;
  352.         } else {
  353.         service->hardLink = handler;
  354.         }
  355.         break;
  356.     case PFS_SYM_LINK:
  357.         oldHandler = service->symLink;
  358.         if (handler == (int (*)())NULL) {
  359.         service->symLink = PfsNullProc;
  360.         } else {
  361.         service->symLink = handler;
  362.         }
  363.         break;
  364.     case PFS_DOMAIN_INFO:
  365.         oldHandler = service->domainInfo;
  366.         if (handler == (int (*)())NULL) {
  367.         service->domainInfo = PfsNullProc;
  368.         } else {
  369.         service->domainInfo = handler;
  370.         }
  371.         break;
  372.     default:
  373.         fprintf(stderr, "Bad operation passed to Pfs_SetHandler");
  374.         oldHandler = NULL;
  375.         break;
  376.     }
  377.     return oldHandler;
  378. }
  379.  
  380. /*
  381.  *----------------------------------------------------------------------
  382.  *
  383.  * PfsNamingRequest --
  384.  *
  385.  *    Called when the naming request-response stream has a new request.
  386.  *    This makes a call-back to the corresponding procedure in the
  387.  *    nameService list for the pseudo-filesystem.
  388.  * 
  389.  * Results:
  390.  *    None.
  391.  *
  392.  * Side effects:
  393.  *    Calls the user's handler for the naming operation.
  394.  *
  395.  *----------------------------------------------------------------------
  396.  */
  397. /*ARGSUSED*/
  398. void
  399. PfsNamingRequest(clientData, streamID, eventMask)
  400.     ClientData clientData;
  401.     int streamID;
  402.     int eventMask;
  403. {
  404.     register Server *pfsPtr = (Server *)clientData;
  405.     Pdev_BufPtrs bufPtrs;
  406.     Pfs_Request *requestPtr;
  407.     Pdev_Reply reply;
  408.     int numBytes;
  409.     Address dataPtr;
  410.     int status;
  411.     int replySize;
  412.     Address replyBuf;
  413.     Fs_Attributes attr;
  414.     Fs_DomainInfo domainInfo;
  415.     Fs_RedirectInfo redirectInfo;
  416.     Fs_2PathRedirectInfo redirect2Info;
  417.  
  418.     if (pfs_Trace) {
  419.     fprintf(stderr, "<%s> ", pfsPtr->prefix);
  420.     }
  421.     /*
  422.      * Read the current pointers for the request buffer.
  423.      */
  424.  
  425.     numBytes = read(streamID, (char *) &bufPtrs, sizeof(Pdev_BufPtrs));
  426.     if (numBytes != sizeof(Pdev_BufPtrs)) {
  427.     panic("%s; status \"%s\", count %d",
  428.         "PfsNamingRequest had trouble reading request buffer pointers",
  429.         strerror(errno), numBytes);
  430.     }
  431.     if (bufPtrs.magic != PDEV_BUF_PTR_MAGIC) {
  432.     panic("%s: %d", "PfsNamingRequest got bad pointer magic number",
  433.         bufPtrs.magic);
  434.     }
  435.     /*
  436.      * While there are still requests in the buffer, service them.
  437.      */
  438.     while (bufPtrs.requestFirstByte < bufPtrs.requestLastByte) {
  439.     requestPtr =
  440.         (Pfs_Request *)&pfsPtr->requestBuf[bufPtrs.requestFirstByte];
  441.     if (requestPtr->hdr.magic != PFS_REQUEST_MAGIC) {
  442.         printf("PfsNamingRequest, bad request magic # 0x%x\n",
  443.                 requestPtr->hdr.magic);
  444.         bufPtrs.requestFirstByte = bufPtrs.requestLastByte + 1;
  445.     }
  446.     dataPtr = (Address)((int)requestPtr + sizeof(Pfs_Request));
  447.  
  448.     status = FS_FILE_NOT_FOUND;
  449.     replySize = 0;
  450.     replyBuf = NULL;
  451.     switch (requestPtr->hdr.operation) {
  452.         case PFS_OPEN: {
  453.         register char *name;
  454.         Fs_OpenArgs *openArgsPtr;
  455.  
  456.         name = (char *)dataPtr;
  457.         openArgsPtr = &requestPtr->param.open;
  458.         if (pfs_Trace) {
  459.             fprintf(stderr, "OPEN %s: uid %d gid %d use %x cwd <%d,%d,%x,%x>",
  460.             name, openArgsPtr->id.user, openArgsPtr->id.group[0],
  461.             openArgsPtr->useFlags,
  462.             openArgsPtr->prefixID.serverID,
  463.             openArgsPtr->prefixID.type, openArgsPtr->prefixID.major,
  464.             openArgsPtr->prefixID.minor);
  465.         }
  466.         status = (*pfsPtr->nameService->open)(pfsPtr->clientData,
  467.                 name, openArgsPtr, &redirectInfo);
  468.         if (status == SUCCESS) {
  469.             /*
  470.              * The openProc has already replied.
  471.              */
  472.             if (pfs_Trace) {
  473.             fprintf(stderr, " Returns OK\n");
  474.             }
  475.             goto nextMsg;
  476.         }
  477.         break;
  478.         }
  479.         case PFS_GET_ATTR: {
  480.         register char *name;
  481.  
  482.         name = (char *)dataPtr;
  483.  
  484.         if (pfs_Trace) {
  485.             fprintf(stderr, "GET_ATTR %s", name);
  486.         }
  487.         status = (*pfsPtr->nameService->getAttr)
  488.             (pfsPtr->clientData, name, &requestPtr->param.getAttr,
  489.             &attr, &redirectInfo);
  490.         if (status == SUCCESS) {
  491.             replyBuf = (Address)&attr;
  492.             replySize = sizeof(Fs_Attributes);
  493.         }
  494.         break;
  495.         }
  496.         case PFS_SET_ATTR: {
  497.         register Pfs_SetAttrData *setAttrPtr =
  498.             (Pfs_SetAttrData *)dataPtr;
  499.  
  500.         if (pfs_Trace) {
  501.             fprintf(stderr, "SET_ATTR %s: ", setAttrPtr->name);
  502.             fprintf(stderr, "client %d uid %d gid %d: ",
  503.             requestPtr->param.open.clientID,
  504.             requestPtr->param.open.id.user,
  505.             requestPtr->param.open.id.group[0]);
  506.             if (setAttrPtr->flags & FS_SET_TIMES) {
  507.             fprintf(stderr, "(access = %d) (modify = %d) ",
  508.                 setAttrPtr->attr.accessTime.seconds,
  509.                 setAttrPtr->attr.dataModifyTime.seconds);
  510.             }
  511.             if (setAttrPtr->flags & FS_SET_MODE) {
  512.             fprintf(stderr, "(mode = 0%o) ", setAttrPtr->attr.permissions);
  513.             }
  514.             if (setAttrPtr->flags & FS_SET_OWNER) {
  515.             fprintf(stderr, "(uid = %d) (gid = %d) ", setAttrPtr->attr.uid,
  516.                     setAttrPtr->attr.gid);
  517.             }
  518.             if (setAttrPtr->flags & FS_SET_FILE_TYPE) {
  519.             fprintf(stderr, "(userType = %d) ", setAttrPtr->attr.userType);
  520.             }
  521.             if (setAttrPtr->flags & FS_SET_DEVICE) {
  522.             fprintf(stderr, "(device = <%d,%d,%d>) ",
  523.                 setAttrPtr->attr.devServerID,
  524.                 setAttrPtr->attr.devType,
  525.                 setAttrPtr->attr.devUnit);
  526.             }
  527.         }
  528.         status = (*pfsPtr->nameService->setAttr)
  529.             (pfsPtr->clientData, setAttrPtr->name,
  530.              &requestPtr->param.setAttr, setAttrPtr->flags,
  531.              &setAttrPtr->attr, &redirectInfo);
  532.         break;
  533.         }
  534.         case PFS_MAKE_DEVICE: {
  535.         register char *name;
  536.  
  537.         name = (char *)dataPtr;
  538.         if (pfs_Trace) {
  539.             fprintf(stderr, "MAKE_DEVICE %s: <%d,%d,%d>", name,
  540.             requestPtr->param.makeDevice.device.serverID,
  541.             requestPtr->param.makeDevice.device.type,
  542.             requestPtr->param.makeDevice.device.unit);
  543.         }
  544.         status = (*pfsPtr->nameService->makeDevice)
  545.             (pfsPtr->clientData, name, &requestPtr->param.makeDevice,
  546.             &redirectInfo);
  547.         break;
  548.         }
  549.         case PFS_MAKE_DIR: {
  550.         register char *name;
  551.  
  552.         name = (char *)dataPtr; 
  553.         if (pfs_Trace) {
  554.             fprintf(stderr, "MAKE_DIR %s", name);
  555.         }
  556.         status = (*pfsPtr->nameService->makeDir)
  557.             (pfsPtr->clientData, name, &requestPtr->param.makeDir,
  558.             &redirectInfo);
  559.         break;
  560.         }
  561.         case PFS_REMOVE: {
  562.         register char *name;
  563.  
  564.         name = (char *)dataPtr;
  565.         if (pfs_Trace) {
  566.             fprintf(stderr, "REMOVE %s", name);
  567.         }
  568.         status = (*pfsPtr->nameService->remove)
  569.             (pfsPtr->clientData, name, &requestPtr->param.remove,
  570.             &redirectInfo);
  571.         break;
  572.         }
  573.         case PFS_REMOVE_DIR: {
  574.         register char *name;
  575.  
  576.         name = (char *)dataPtr;
  577.         if (pfs_Trace) {
  578.             fprintf(stderr, "REMOVE %s", name);
  579.         }
  580.         status = (*pfsPtr->nameService->removeDir)
  581.             (pfsPtr->clientData, name, &requestPtr->param.removeDir,
  582.             &redirectInfo);
  583.         break;
  584.         }
  585.         case PFS_RENAME: {
  586.         register Fs_2PathData *pathsPtr;
  587.  
  588.         pathsPtr = (Fs_2PathData *)dataPtr;
  589.         if (pfs_Trace) {
  590.             fprintf(stderr, "PFS_RENAME %s %s", 
  591.             pathsPtr->path1, pathsPtr->path2);
  592.         }
  593.         status = (*pfsPtr->nameService->rename)
  594.             (pfsPtr->clientData, pathsPtr->path1, pathsPtr->path2,
  595.             &requestPtr->param.rename, &redirect2Info);
  596.         break;
  597.         }
  598.         case PFS_HARD_LINK: {
  599.         register Fs_2PathData *pathsPtr;
  600.  
  601.         pathsPtr = (Fs_2PathData *)dataPtr;
  602.         if (pfs_Trace) {
  603.             fprintf(stderr, "PFS_HARD_LINK %s %s", 
  604.             pathsPtr->path1, pathsPtr->path2);
  605.         }
  606.         status = (*pfsPtr->nameService->hardLink)
  607.             (pfsPtr->clientData, pathsPtr->path1, pathsPtr->path2,
  608.             &requestPtr->param.hardLink, &redirect2Info);
  609.         break;
  610.         }
  611.         case PFS_SYM_LINK: {
  612.         register Fs_2PathData *pathsPtr;
  613.  
  614.         pathsPtr = (Fs_2PathData *)dataPtr;
  615.         if (pfs_Trace) {
  616.             fprintf(stderr, "PFS_SYM_LINK %s %s", 
  617.             pathsPtr->path1, pathsPtr->path2);
  618.         }
  619.         status = (*pfsPtr->nameService->symLink)
  620.             (pfsPtr->clientData, pathsPtr->path1, pathsPtr->path2,
  621.             &requestPtr->param.symLink, &redirectInfo);
  622.         break;
  623.         }
  624.         case PFS_DOMAIN_INFO: {
  625.         if (pfs_Trace) {
  626.             fprintf(stderr, "PFS_DOMAIN_INFO");
  627.         }
  628.         status = (*pfsPtr->nameService->domainInfo)
  629.             (pfsPtr->clientData, &requestPtr->param.domainInfo,
  630.             &domainInfo);
  631.         replyBuf = (Address)&domainInfo;
  632.         replySize = sizeof(domainInfo);
  633.         break;
  634.         }
  635.         default:
  636.         panic("PfsNamingRequest: bad request on request stream: %d",
  637.             requestPtr->hdr.operation);
  638.     }
  639.     if (status == EREMOTE || status == FS_LOOKUP_REDIRECT) {
  640.         status = FS_LOOKUP_REDIRECT;
  641.         if (requestPtr->hdr.operation == PFS_RENAME ||
  642.         requestPtr->hdr.operation == PFS_HARD_LINK) {
  643.         replyBuf = (Address)&redirect2Info;
  644.         replySize = sizeof(Fs_2PathRedirectInfo);
  645.         } else {
  646.         replyBuf = (Address)&redirectInfo;
  647.         replySize = sizeof(Fs_RedirectInfo);
  648.         }
  649.     }
  650.     if (pfs_Trace) {
  651.         fprintf(stderr, " Returns %x\n", status);
  652.     }
  653.     reply.magic = PDEV_REPLY_MAGIC;
  654.     reply.status = status;
  655.     reply.replyBuf = replyBuf;
  656.     reply.replySize = replySize;
  657.     reply.selectBits = 0;
  658.     reply.signal = 0;
  659.     reply.code = 0;
  660.     status = Fs_IOControl(streamID, IOC_PDEV_REPLY,
  661.         sizeof(Pdev_Reply), (Address) &reply, 0, (Address) NULL);
  662.     if (status != SUCCESS) {
  663.         fprintf(stderr, "IOC_PDEV_REPLY status 0x%x\n", status);
  664.     }
  665.     /*
  666.      * Check the next message.
  667.      */
  668. nextMsg:
  669.     bufPtrs.requestFirstByte += requestPtr->hdr.messageSize;
  670.     }
  671.     /*
  672.      * Tell the kernel we've processed the messages.
  673.      */
  674.     (void)Fs_IOControl(streamID, IOC_PDEV_SET_PTRS,
  675.             sizeof(Pdev_BufPtrs), (Address)&bufPtrs,
  676.             0, (Address) NULL);
  677. }
  678.  
  679. /*
  680.  *----------------------------------------------------------------------
  681.  *
  682.  * Pfs_OpenConnection --
  683.  *
  684.  *    Called to open a new pdev connection in response to an PFS_OPEN
  685.  *    request.  This does an IOC_PFS_OPEN to set up the connection, and
  686.  *    the sets up a call-back to PdevServiceRequest to handle the subsequent
  687.  *    operations on the new connection.  The pdev handlers are the
  688.  *    default ones until updated with Pdev_SetupHandler.
  689.  * 
  690.  * Results:
  691.  *    None.
  692.  *
  693.  * Side effects:
  694.  *    Turns off tracing, etc.
  695.  *
  696.  *----------------------------------------------------------------------
  697.  */
  698. Pdev_Stream *
  699. Pfs_OpenConnection(token, fileIDPtr, reqBufSize, readBufSize, readBuf, selectBits, service)
  700.     Pfs_Token token;        /* Ref. to pseudo-file-system state */
  701.     Fs_FileID *fileIDPtr;    /* Server's name for this conection */
  702.     int reqBufSize;        /* Preferred size for request buffer */
  703.     int readBufSize;        /* Size for optional read buffer, 0 means
  704.                  * no read buffer */
  705.     char *readBuf;        /* The read buffer itself, or NULL */
  706.     int selectBits;        /* Initial select state of the connection */
  707.     Pdev_CallBacks *service;    /* Set of handlers for this pdev connection */
  708. {
  709.     int newStreamID;
  710.     register Server *pfsPtr = (Server *)token;
  711.     Pdev_SetBufArgs setBuf;
  712.     int status;
  713.  
  714.     if (pfsPtr->magic != PFS_MAGIC) {
  715.     fprintf(stderr, "Pfs_OpenConnection got bad token\n");
  716.     return NULL;
  717.     }
  718.     status = Fs_IOControl(pfsPtr->streamID, IOC_PFS_OPEN, sizeof(Fs_FileID),
  719.         fileIDPtr, sizeof(int), (Address)&newStreamID);
  720.     if (status != SUCCESS) {
  721.     fprintf(stderr, "IOC_PFS_OPEN failed <%x>\n", status);
  722.     return NULL;
  723.     }
  724.     /*
  725.      * Set up state for the new pseudo-device connection
  726.      */
  727.     return (PdevSetup(newStreamID, (Address)pfsPtr, &pfsPtr->connectList,
  728.         reqBufSize, readBufSize, readBuf, service, selectBits));
  729.  
  730. }
  731.  
  732. /*
  733.  *----------------------------------------------------------------------
  734.  *
  735.  * Pfs_PassFile --
  736.  *
  737.  *    Pass off an open file in response to an open request by a client.
  738.  *    This takes a regular open file descriptor and passes it into the
  739.  *    kernel in response to an open request by a client.  This should
  740.  *    only be called from the open call-back service procedure.
  741.  *
  742.  * Results:
  743.  *    An error code.
  744.  *
  745.  * Side effects:
  746.  *    Completes a PFS_OPEN transaction by making the IOC_PFS_PASS_STREAM
  747.  *    ioctl to pass off the open file descriptor.
  748.  *
  749.  *----------------------------------------------------------------------
  750.  */
  751. int
  752. Pfs_PassFile(pfsToken, streamID)
  753.     Pfs_Token pfsToken;
  754.     int streamID;
  755. {
  756.     register Server *pfsPtr = (Server *)pfsToken;
  757.     register int status;
  758.  
  759.     if (pfsPtr->magic != PFS_MAGIC) {
  760.     fprintf(stderr, "Pfs_PassFile got bad token\n");
  761.     return EINVAL;
  762.     }
  763.     status = Fs_IOControl(pfsPtr->streamID, IOC_PFS_PASS_STREAM, sizeof(int),
  764.         &streamID, 0, NULL);
  765.     return status;
  766. }
  767.  
  768. /*
  769.  *----------------------------------------------------------------------
  770.  *
  771.  * Pfs_Close --
  772.  *
  773.  *    Stop pseudo-file-system service.
  774.  *
  775.  * Results:
  776.  *    None.
  777.  *
  778.  * Side effects:
  779.  *    Closes the naming request-response stream and free's up alloc'd memory.
  780.  *
  781.  *----------------------------------------------------------------------
  782.  */
  783. void
  784. Pfs_Close(pfsToken)
  785.     Pfs_Token pfsToken;
  786. {
  787.     register Server *pfsPtr = (Server *)pfsToken;
  788.  
  789.     if (pfsPtr->magic != PFS_MAGIC) {
  790.     fprintf(stderr, "Pfs_Close got bad token\n");
  791.     return;
  792.     }
  793.     (void)close(pfsPtr->streamID);
  794.     (void)free((char *)pfsPtr->nameService);
  795.     (void)free((char *)pfsPtr->requestBuf);
  796.     (void)free((char *)pfsPtr);
  797. }
  798.  
  799. /*
  800.  *----------------------------------------------------------------------
  801.  *
  802.  * PfsNullProc --
  803.  *
  804.  *    Do-nothing callback.
  805.  *
  806.  * Results:
  807.  *    Returns FS_FILE_NOT_FOUND.
  808.  *
  809.  * Side effects:
  810.  *    None.
  811.  *
  812.  *----------------------------------------------------------------------
  813.  */
  814. static int
  815. PfsNullProc()
  816. {
  817.     return(FS_FILE_NOT_FOUND);
  818. }
  819. @
  820.  
  821.  
  822. 1.5.1.1
  823. log
  824. @Initial branch for Sprite server.
  825. @
  826. text
  827. @d27 1
  828. a27 1
  829. static char rcsid[] = "$Header: /sprite/src/lib/c/etc/RCS/pfs.c,v 1.5 89/09/12 14:42:42 brent Exp $ SPRITE (Berkeley)";
  830. @
  831.  
  832.  
  833. 1.4
  834. log
  835. @Added PFS_DOMAIN_INFO
  836. @
  837. text
  838. @d27 1
  839. a27 1
  840. static char rcsid[] = "$Header: /sprite/src/lib/c/etc/RCS/pfs.c,v 1.3 89/06/02 15:01:22 brent Exp Locker: brent $ SPRITE (Berkeley)";
  841. d82 1
  842. a82 1
  843. #define PFS_REQUEST_BUF_SIZE    (sizeof(Pfs_Request) + sizeof(Fs2PathData))
  844. d366 2
  845. a367 2
  846.     FsRedirectInfo redirectInfo;
  847.     Fs2PathRedirectInfo redirect2Info;
  848. d393 1
  849. a393 1
  850.         panic("PfsNamingRequest, bad request magic # 0x%x\n",
  851. d395 1
  852. d405 1
  853. a405 1
  854.         FsOpenArgs *openArgsPtr;
  855. d537 1
  856. a537 1
  857.         register Fs2PathData *pathsPtr;
  858. d539 1
  859. a539 1
  860.         pathsPtr = (Fs2PathData *)dataPtr;
  861. d550 1
  862. a550 1
  863.         register Fs2PathData *pathsPtr;
  864. d552 1
  865. a552 1
  866.         pathsPtr = (Fs2PathData *)dataPtr;
  867. d563 1
  868. a563 1
  869.         register Fs2PathData *pathsPtr;
  870. d565 1
  871. a565 1
  872.         pathsPtr = (Fs2PathData *)dataPtr;
  873. d595 1
  874. a595 1
  875.         replySize = sizeof(Fs2PathRedirectInfo);
  876. d598 1
  877. a598 1
  878.         replySize = sizeof(FsRedirectInfo);
  879. @
  880.  
  881.  
  882. 1.3
  883. log
  884. @Updated to new pseudo-device interface with signalas
  885. @
  886. text
  887. @d27 1
  888. a27 1
  889. static char rcsid[] = "$Header: /sprite/src/lib/c/etc/RCS/pfs.c,v 1.2 89/04/06 08:23:20 brent Exp Locker: brent $ SPRITE (Berkeley)";
  890. d75 1
  891. d178 3
  892. d315 8
  893. d364 2
  894. a430 1
  895.         Fs_Attributes attr;
  896. d572 11
  897. @
  898.  
  899.  
  900. 1.2
  901. log
  902. @Fixed up Pfs_Request.param usage.  There is one union branch
  903. per operation.
  904. @
  905. text
  906. @d27 1
  907. a27 1
  908. static char rcsid[] = "$Header: /sprite/src/lib/c/etc/RCS/pfs.c,v 1.1 89/02/02 15:00:39 brent Exp Locker: brent $ SPRITE (Berkeley)";
  909. d584 2
  910. @
  911.  
  912.  
  913. 1.1
  914. log
  915. @Initial revision
  916. @
  917. text
  918. @d27 1
  919. a27 1
  920. static char rcsid[] = "$Header: /sprite/src/lib/c/etc/RCS/pdev.c,v 1.5 89/01/06 07:59:52 brent Exp $ SPRITE (Berkeley)";
  921. d63 1
  922. a63 1
  923. extern int    PfsNullProc();
  924. d127 2
  925. a128 2
  926.     sprintf(pfs_ErrorMsg, "Pfs_Open: \"%s\" service failed <%x>",
  927.         prefix, status);
  928. d425 1
  929. a425 1
  930.             (pfsPtr->clientData, name, &requestPtr->param.open,
  931. d467 1
  932. a467 1
  933.              &requestPtr->param.open, setAttrPtr->flags,
  934. d494 1
  935. a494 1
  936.             (pfsPtr->clientData, name, &requestPtr->param.open,
  937. d506 2
  938. a507 2
  939.                 (pfsPtr->clientData, name, &requestPtr->param.lookup,
  940.                 &redirectInfo);
  941. d518 1
  942. a518 1
  943.             (pfsPtr->clientData, name, &requestPtr->param.lookup,
  944. d545 1
  945. a545 1
  946.             &requestPtr->param.rename, &redirect2Info);
  947. d558 1
  948. a558 1
  949.             &requestPtr->param.open, &redirectInfo);
  950. @
  951.